home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / Sherlock 2.0 / SDEL / SDELsrc / sdel_arg.c next >
Text File  |  1996-04-02  |  5KB  |  267 lines
  1. /*
  2.     SDEL: argument processing.
  3.     
  4.     source: sdel_arg.c
  5.     started: April 2, 1996.
  6.     version: April 2, 1996.
  7. */
  8.  
  9. #include "sdel.h"
  10. #include "sdel_arg.h"
  11.  
  12. #include <LIBend.h>
  13.  
  14. #include <ctype.h>
  15. #include <string.h>
  16. #include <stdlib.h>
  17.  
  18. // Public globals
  19.  
  20. bool    disable_flag  = FALSE;    /* TRUE: retain SL_DISABLE        */
  21. bool    include_flag  = FALSE;    /* TRUE: remove #include sl.h    */
  22. bool    name_flag      = FALSE;    /* TRUE: retain SL_NAME            */
  23. bool    nest_flag      = FALSE;    /* TRUE: allow nested comments.    */
  24. bool    trigraph_flag = FALSE;    /* TRUE: output trigraphs.        */
  25.  
  26. // Private prototypes
  27.  
  28. static void help         (void);
  29. static void    set_syn        (char * id1, char * id2);
  30. static char * str_alloc    (char * string);
  31. static void    synonyms    (void);
  32.  
  33. /*
  34.     Handle command line arguments.
  35. */
  36. void
  37. arg_do_argv(int argc, char **argv)
  38. {
  39.     char * arg = NULL;
  40.     
  41.     SL_DISABLE();
  42.  
  43.     /* Test for correct command line. */
  44.     if (argc < 3) {
  45.         help();
  46.         end_usage();
  47.     }
  48.  
  49.     /* Process all the arguments on the command line. */
  50.     argc--;
  51.     argv++;
  52.     while (argc-- > 0) {
  53.         arg = *argv++;
  54.  
  55.         if (str_eq(arg, "-d")) {
  56.             disable_flag = TRUE;
  57.         }
  58.         else if (str_eq(arg, "-f")) {
  59.             if (argc--) {
  60.                 arg = *argv++;
  61.                 syn_file_name = arg;
  62.                 
  63.                 syn_file = fopen(syn_file_name, "r");
  64.                 if (in_file) {
  65.                     es("Can not open synonym file: "); es(syn_file_name); enl();
  66.                     end_quit();
  67.                 }
  68.                 synonyms();
  69.                 fclose(syn_file);
  70.                 syn_file = NULL;
  71.             }
  72.             else {
  73.                 es("Trailing -f");
  74.                 end_usage();
  75.             }
  76.         }
  77.         else if (str_eq(arg, "-i")) {
  78.             /* Remove #include "sl.h" or <sl.h> */
  79.             include_flag = TRUE;
  80.         }
  81.         else if (str_eq(arg, "-n")) {
  82.             /* Disallow nested comments. */
  83.             nest_flag = FALSE;
  84.         }
  85.         else if (str_eq(arg, "-t")) {
  86.             /* Allow trigraph translation. */
  87.             trigraph_flag = TRUE;
  88.         }
  89.         else if (str_eq(arg, "-r")) {
  90.             /* Retain SL_NAME. */
  91.             name_flag = TRUE;
  92.         }
  93.         else if (str_eq(arg, "-?")) {
  94.             /* Ignore it. */
  95.             ;
  96.         }
  97.         else if (in_file_name == NULL) {
  98.             in_file_name = arg;
  99.         }
  100.         else if (out_file_name == NULL) {
  101.             out_file_name = arg;
  102.         }
  103.         else {
  104.             es("Extra file argument: "); es(arg);
  105.             end_usage();
  106.         }
  107.     }
  108.  
  109.     /* Make sure that both file arguments were provided. */
  110.     if (in_file_name == NULL) {
  111.         es("Missing input, output file arguments\n");
  112.         end_usage();
  113.     }
  114.     else if (out_file_name == NULL) {
  115.         es("Missing output file argument\n");
  116.         end_usage();
  117.     }
  118.     else if (str_eq(in_file_name, out_file_name)) {
  119.         es("Can not copy input file to output file\n");
  120.         end_usage();
  121.     }
  122.     
  123.     /* Open the files. */
  124.     #if 0
  125.         out_file = fopen(out_file_name, "r");
  126.         if (out_file) {
  127.             es("Output file: "); es(out_file_name); es(" exists"); enl();
  128.             end_usage();
  129.         }
  130.     #endif
  131.  
  132.     out_file = fopen(out_file_name, "w");
  133.     if (!out_file) {
  134.         es("Can not create "); es(out_file_name); enl();
  135.         end_usage();
  136.     }
  137.  
  138.     in_file = fopen(in_file_name, "r");
  139.     if (!in_file) {
  140.         es("Can not open "); es(in_file_name); enl();
  141.         end_usage();
  142.     }
  143. }
  144.  
  145. static void
  146. help (void)
  147. {
  148.     es("SDEL in out [options]\n\n");
  149.  
  150.     es("-d        retain SL_DISABLE macros\n");
  151.     es("-f <file> rename macros using a synonym file\n");
  152.     es("-i        remove #include sl.h lines\n");
  153.     es("-n        disallow nested comments\n");
  154.     es("-r        retain SL_NAME macros\n");
  155.     es("-t        allow trigraph translation\n");
  156.     es("-?        print version number and exit\n");
  157. }
  158.  
  159. /*
  160.     Change the spelling of a Sherlock macro to a synonym.
  161. */
  162. static void
  163. set_syn(char * id1, char * id2)
  164. {
  165.     int i;
  166.         
  167.     /* Special cases. */
  168.     if (str_eq(id1, r_void)) {
  169.         r_void = str_alloc(id2);
  170.         return;
  171.     }
  172.     else if (str_eq(id1, s_disable)) {
  173.         s_disable = str_alloc(id2);
  174.         return;
  175.     }
  176.     else if    (str_eq(id1, s_name)) {
  177.         s_name = str_alloc(id2);
  178.         return;
  179.     }
  180.  
  181.     /* All return macros except RETURN_VOID. */
  182.     for (i = 0; rmn_tab[i] != NULL; i++) {
  183.         if (str_eq(rmn_tab[i], id1)) {
  184.             rmn_tab[i] = str_alloc(id2);
  185.             return;
  186.         }
  187.     }
  188.  
  189.     /* All other Sherlock macros. */
  190.     for (i = 0; mn_tab[i] != NULL; i++) {
  191.         if (str_eq(mn_tab[i], id1)) {
  192.             mn_tab[i] = str_alloc(id2);
  193.             return;
  194.         }
  195.     }
  196.     es("Synonym entry for "); es(id1); es(" has no effect.\n");
  197. }
  198.  
  199. /*
  200.     Allocate memory big enough to hold the string,
  201.     then copy the string to the allocated memory.
  202. */
  203. char *
  204. str_alloc(char *s)
  205. {
  206.     char * p;
  207.     int n;
  208.  
  209.     n = strlen(s) + 1;
  210.     p = malloc(n);
  211.     strcpy(p, s);
  212.  
  213.     return p;
  214. }
  215.  
  216. /*
  217.     Process a synonym file.
  218. */
  219. void
  220. synonyms(void)
  221. {
  222.     char buffer1 [1000];
  223.     char buffer2 [1000];
  224.     
  225.     skip_bl();
  226.     while (ch != EOF) {
  227.         if (isid1(ch)) {
  228.             get_id(&buffer1[0]);
  229.             skip_bl();
  230.             if (isid1(ch))
  231.             {
  232.                 get_id(&buffer2[0]);
  233.                 set_syn(&buffer1[0], &buffer2[0]);
  234.                 skip_bl();
  235.                 if (ch == '\n') {
  236.                     next_ch();
  237.                     line++;
  238.                     skip_bl();
  239.                 }
  240.                 else {
  241.                     error(es("Newline expected in synonym file"));
  242.                     end_usage();
  243.                 }
  244.             }
  245.             else {
  246.                 error(es("Synonym expected in synonym file"));
  247.                 end_usage();
  248.             }
  249.         }
  250.         else if (ch == ' ' || ch == '\t' || ch == '\n') {
  251.             if (ch == '\n') {
  252.                 line++;
  253.             }
  254.             next_ch();
  255.         }
  256.         else if (ch == '#') {
  257.             while (ch != '\n' && ch != EOF) {
  258.                 next_ch();
  259.             }
  260.         }
  261.         else {
  262.             error(es("Identifier expected in synonym file"));
  263.             end_usage();
  264.         }
  265.     }
  266. }
  267.